package feign;

import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.WildcardType;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

import static java.lang.String.format;

/**
 * Utilities, typically copied in from guava, so as to avoid dependency conflicts.
 */
public class Util {

    /**
     * The HTTP Content-Length header field name.
     */
    public static final String CONTENT_LENGTH = "Content-Length";
    /**
     * The HTTP Content-Encoding header field name.
     */
    public static final String CONTENT_ENCODING = "Content-Encoding";
    /**
     * The HTTP Retry-After header field name.
     */
    public static final String RETRY_AFTER = "Retry-After";
    /**
     * Value for the Content-Encoding header that indicates that GZIP encoding is in use.
     */
    public static final String ENCODING_GZIP = "gzip";
    /**
     * Value for the Content-Encoding header that indicates that DEFLATE encoding is in use.
     */
    public static final String ENCODING_DEFLATE = "deflate";
    /**
     * UTF-8: eight-bit UCS Transformation Format.
     */
    public static final Charset UTF_8 = StandardCharsets.UTF_8;

    // com.google.common.base.Charsets
    /**
     * ISO-8859-1: ISO Latin Alphabet Number 1 (ISO-LATIN-1).
     */
    public static final Charset ISO_8859_1 = StandardCharsets.ISO_8859_1;

    // java中的编码是unicode16的,所以一个char是16位二进制位,所以占两个字节。
    private static final int BUF_SIZE = 0x800; // 2K chars (4K bytes)

    /**
     * Type literal for {@code Map<String, ?>}. 字面意义类型
     */
    public static final Type MAP_STRING_WILDCARD = new Types.ParameterizedTypeImpl(null, Map.class, String.class, new Types.WildcardTypeImpl(new Type[]{Object.class}, new Type[0]));

    private Util() { // no instances
    }

    /**
     * Copy of {@code com.google.common.base.Preconditions#checkArgument}.
     */
    public static void checkArgument(boolean expression, String errorMessageTemplate, Object... errorMessageArgs) {
        if (!expression) {
            throw new IllegalArgumentException(format(errorMessageTemplate, errorMessageArgs));
        }
    }

    /**
     * Copy of {@code com.google.common.base.Preconditions#checkNotNull}.
     */
    public static <T> T checkNotNull(T reference, String errorMessageTemplate, Object... errorMessageArgs) {
        if (reference == null) {
            // If either of these parameters is null, the right thing happens anyway
            throw new NullPointerException(format(errorMessageTemplate, errorMessageArgs));
        }
        return reference;
    }

    /**
     * Copy of {@code com.google.common.base.Preconditions#checkState}.
     */
    public static void checkState(boolean expression, String errorMessageTemplate, Object... errorMessageArgs) {
        if (!expression) {
            throw new IllegalStateException(format(errorMessageTemplate, errorMessageArgs));
        }
    }

    /**
     * Identifies a method as a default instance method.
     */
    public static boolean isDefault(Method method) {
        // Default methods are public non-abstract, non-synthetic, and non-static instance methods declared in an interface.
        // method.isDefault() is not sufficient for our usage as it does not check for synthetic methods. As a result, it picks up overridden methods as well as actual default methods.
        final int SYNTHETIC = 0x00001000;
        return ((method.getModifiers() & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC | SYNTHETIC)) == Modifier.PUBLIC) && method.getDeclaringClass().isInterface();
    }


    public static String emptyToNull(String string) {
        return string == null || string.isEmpty() ? null : string;
    }

    public static void main(String[] args) {
        String[] values = new String[]{"", null};
        String[] res = removeValues(values, (value) -> emptyToNull(value) == null, String.class);
        System.out.println(res);
    }

    @SuppressWarnings("unchecked")
    public static <T> T[] removeValues(T[] values, Predicate<T> shouldRemove, Class<T> type) {
        Collection<T> collection = new ArrayList<>(values.length);
        for (T value : values) {
            if (shouldRemove.negate().test(value)) {
                collection.add(value);
            }
        }
        T[] array = (T[]) Array.newInstance(type, collection.size());
        return collection.toArray(array);
    }

    /**
     * Adapted from {@code com.google.common.base.Strings#emptyToNull}.
     */
    @SuppressWarnings("unchecked")
    public static <T> T[] toArray(Iterable<? extends T> iterable, Class<T> type) {
        Collection<T> collection;
        if (iterable instanceof Collection) {
            collection = (Collection<T>) iterable;
        } else {
            collection = new ArrayList<T>();
            for (T element : iterable) {
                collection.add(element);
            }
        }
        T[] array = (T[]) Array.newInstance(type, collection.size());
        return collection.toArray(array);
    }

    /**
     * Returns an unmodifiable collection which may be empty, but is never null.
     */
    public static <T> Collection<T> valuesOrEmpty(Map<String, Collection<T>> map, String key) {
        Collection<T> values = map.get(key);
        return values != null ? values : Collections.emptyList();
    }

    public static void ensureClosed(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException ignored) { // NOPMD
            }
        }
    }

    /**
     * Resolves the last type parameter of the parameterized {@code supertype}, based on the {@code
     * genericContext}, into its upper bounds.
     * <p/>
     * Implementation copied from {@code
     * retrofit.RestMethodInfo}.
     *
     * @param genericContext Ex. {@link java.lang.reflect.Field#getGenericType()}
     * @param supertype      Ex. {@code Decoder.class}
     * @return in the example above, the type parameter of {@code Decoder}.
     * @throws IllegalStateException if {@code supertype} cannot be resolved into a parameterized type
     *                               using {@code context}.
     */
    public static Type resolveLastTypeParameter(Type genericContext, Class<?> supertype) throws IllegalStateException {
        Type resolvedSuperType = Types.getSupertype(genericContext, Types.getRawType(genericContext), supertype);
        checkState(resolvedSuperType instanceof ParameterizedType, "could not resolve %s into a parameterized type %s", genericContext, supertype);
        Type[] types = ParameterizedType.class.cast(resolvedSuperType).getActualTypeArguments();
        for (int i = 0; i < types.length; i++) {
            Type type = types[i];
            if (type instanceof WildcardType) {
                types[i] = ((WildcardType) type).getUpperBounds()[0];
            }
        }
        return types[types.length - 1];
    }

    /**
     * This returns well known empty values for well-known java types. This returns null for types not
     * in the following list.
     *
     * <ul>
     * <li>{@code [Bb]oolean}</li>
     * <li>{@code byte[]}</li>
     * <li>{@code Collection}</li>
     * <li>{@code Iterator}</li>
     * <li>{@code List}</li>
     * <li>{@code Map}</li>
     * <li>{@code Set}</li>
     * </ul>
     * <p>
     * <p/>
     * When {@link Feign.Builder#decode404() decoding HTTP 404 status}, you'll need to teach decoders
     * a default empty value for a type. This method cheaply supports typical types by only looking at
     * the raw type (vs type hierarchy). Decorate for sophistication.
     */
    public static Object emptyValueOf(Type type) {
        return EMPTIES.getOrDefault(Types.getRawType(type), () -> null).get();
    }

    private static final Map<Class<?>, Supplier<Object>> EMPTIES;

    static {
        final Map<Class<?>, Supplier<Object>> empties = new LinkedHashMap<Class<?>, Supplier<Object>>();
        empties.put(boolean.class, () -> false);
        empties.put(Boolean.class, () -> false);
        empties.put(byte[].class, () -> new byte[0]);
        empties.put(Collection.class, Collections::emptyList);
        empties.put(Iterator.class, Collections::emptyIterator);
        empties.put(List.class, Collections::emptyList);
        empties.put(Map.class, Collections::emptyMap);
        empties.put(Set.class, Collections::emptySet);
        empties.put(Optional.class, Optional::empty);
        empties.put(Stream.class, Stream::empty);
        EMPTIES = Collections.unmodifiableMap(empties);
    }

    /**
     * Adapted from {@code com.google.common.io.CharStreams.toString()}.
     */
    public static String toString(Reader reader) throws IOException {
        if (reader == null) {
            return null;
        }
        try {
            StringBuilder to = new StringBuilder();
            CharBuffer charBuf = CharBuffer.allocate(BUF_SIZE);
            // must cast to super class Buffer otherwise break when running with java 11
            while (reader.read(charBuf) != -1) {
                charBuf.flip();
                to.append(charBuf);
                charBuf.clear();
            }
            return to.toString();
        } finally {
            ensureClosed(reader);
        }
    }

    /**
     * Adapted from {@code com.google.common.io.ByteStreams.toByteArray()}.
     */
    public static byte[] toByteArray(InputStream in) throws IOException {
        checkNotNull(in, "in");
        try {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            copy(in, out);
            return out.toByteArray();
        } finally {
            ensureClosed(in);
        }
    }

    /**
     * Adapted from {@code com.google.common.io.ByteStreams.copy()}.
     */
    private static long copy(InputStream from, OutputStream to) throws IOException {
        checkNotNull(from, "from");
        checkNotNull(to, "to");
        byte[] buf = new byte[BUF_SIZE];
        long total = 0;
        while (true) {
            int r = from.read(buf);
            if (r == -1) {
                break;
            }
            to.write(buf, 0, r);
            total += r;
        }
        return total;
    }

    public static String decodeOrDefault(byte[] data, Charset charset, String defaultValue) {
        if (data == null) {
            return defaultValue;
        }
        checkNotNull(charset, "charset");
        try {
            return charset.newDecoder().decode(ByteBuffer.wrap(data)).toString();
        } catch (CharacterCodingException ex) {
            return defaultValue;
        }
    }

    public static boolean isNotBlank(String value) {
        return value != null && !value.isEmpty();
    }

    public static boolean isBlank(String value) {
        return value == null || value.isEmpty();
    }
}
